//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS AuditManager service.
///
/// Welcome to the Audit Manager API reference. This guide is for developers who need detailed information about the Audit Manager API operations, data types, and errors.  Audit Manager is a service that provides automated evidence collection so that you can continually audit your Amazon Web Services usage. You can use it to assess the effectiveness of your controls, manage risk, and simplify compliance. Audit Manager provides prebuilt frameworks that structure and automate assessments for a given compliance standard. Frameworks include a prebuilt collection of controls with descriptions and testing procedures. These controls are grouped according to the requirements of the specified compliance standard or regulation. You can also customize frameworks and controls to support internal audits with specific requirements.  Use the following links to get started with the Audit Manager API:    Actions: An alphabetical list of all Audit Manager API operations.    Data types: An alphabetical list of all Audit Manager data types.    Common parameters: Parameters that all operations can use.    Common errors: Client and server errors that all operations can return.   If you're new to Audit Manager, we recommend that you review the  Audit Manager User Guide.
public struct AuditManager: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the AuditManager client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "AuditManager",
            serviceIdentifier: "auditmanager",
            serviceProtocol: .restjson,
            apiVersion: "2017-07-25",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: AuditManagerErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "us-east-1": "auditmanager-fips.us-east-1.amazonaws.com",
            "us-east-2": "auditmanager-fips.us-east-2.amazonaws.com",
            "us-west-1": "auditmanager-fips.us-west-1.amazonaws.com",
            "us-west-2": "auditmanager-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    ///  Associates an evidence folder to an assessment report in an Audit Manager assessment.
    @Sendable
    @inlinable
    public func associateAssessmentReportEvidenceFolder(_ input: AssociateAssessmentReportEvidenceFolderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateAssessmentReportEvidenceFolderResponse {
        try await self.client.execute(
            operation: "AssociateAssessmentReportEvidenceFolder", 
            path: "/assessments/{assessmentId}/associateToAssessmentReport", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Associates an evidence folder to an assessment report in an Audit Manager assessment.
    ///
    /// Parameters:
    ///   - assessmentId:  The identifier for the assessment.
    ///   - evidenceFolderId:  The identifier for the folder that the evidence is stored in.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateAssessmentReportEvidenceFolder(
        assessmentId: String,
        evidenceFolderId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateAssessmentReportEvidenceFolderResponse {
        let input = AssociateAssessmentReportEvidenceFolderRequest(
            assessmentId: assessmentId, 
            evidenceFolderId: evidenceFolderId
        )
        return try await self.associateAssessmentReportEvidenceFolder(input, logger: logger)
    }

    ///  Associates a list of evidence to an assessment report in an Audit Manager assessment.
    @Sendable
    @inlinable
    public func batchAssociateAssessmentReportEvidence(_ input: BatchAssociateAssessmentReportEvidenceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchAssociateAssessmentReportEvidenceResponse {
        try await self.client.execute(
            operation: "BatchAssociateAssessmentReportEvidence", 
            path: "/assessments/{assessmentId}/batchAssociateToAssessmentReport", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Associates a list of evidence to an assessment report in an Audit Manager assessment.
    ///
    /// Parameters:
    ///   - assessmentId:  The identifier for the assessment.
    ///   - evidenceFolderId:  The identifier for the folder that the evidence is stored in.
    ///   - evidenceIds:  The list of evidence identifiers.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchAssociateAssessmentReportEvidence(
        assessmentId: String,
        evidenceFolderId: String,
        evidenceIds: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchAssociateAssessmentReportEvidenceResponse {
        let input = BatchAssociateAssessmentReportEvidenceRequest(
            assessmentId: assessmentId, 
            evidenceFolderId: evidenceFolderId, 
            evidenceIds: evidenceIds
        )
        return try await self.batchAssociateAssessmentReportEvidence(input, logger: logger)
    }

    ///  Creates a batch of delegations for an assessment in Audit Manager.
    @Sendable
    @inlinable
    public func batchCreateDelegationByAssessment(_ input: BatchCreateDelegationByAssessmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchCreateDelegationByAssessmentResponse {
        try await self.client.execute(
            operation: "BatchCreateDelegationByAssessment", 
            path: "/assessments/{assessmentId}/delegations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates a batch of delegations for an assessment in Audit Manager.
    ///
    /// Parameters:
    ///   - assessmentId:  The identifier for the assessment.
    ///   - createDelegationRequests:  The API request to batch create delegations in Audit Manager.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchCreateDelegationByAssessment(
        assessmentId: String,
        createDelegationRequests: [CreateDelegationRequest],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchCreateDelegationByAssessmentResponse {
        let input = BatchCreateDelegationByAssessmentRequest(
            assessmentId: assessmentId, 
            createDelegationRequests: createDelegationRequests
        )
        return try await self.batchCreateDelegationByAssessment(input, logger: logger)
    }

    ///  Deletes a batch of delegations for an assessment in Audit Manager.
    @Sendable
    @inlinable
    public func batchDeleteDelegationByAssessment(_ input: BatchDeleteDelegationByAssessmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchDeleteDelegationByAssessmentResponse {
        try await self.client.execute(
            operation: "BatchDeleteDelegationByAssessment", 
            path: "/assessments/{assessmentId}/delegations", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes a batch of delegations for an assessment in Audit Manager.
    ///
    /// Parameters:
    ///   - assessmentId:  The identifier for the assessment.
    ///   - delegationIds:  The identifiers for the delegations.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchDeleteDelegationByAssessment(
        assessmentId: String,
        delegationIds: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchDeleteDelegationByAssessmentResponse {
        let input = BatchDeleteDelegationByAssessmentRequest(
            assessmentId: assessmentId, 
            delegationIds: delegationIds
        )
        return try await self.batchDeleteDelegationByAssessment(input, logger: logger)
    }

    ///  Disassociates a list of evidence from an assessment report in Audit Manager.
    @Sendable
    @inlinable
    public func batchDisassociateAssessmentReportEvidence(_ input: BatchDisassociateAssessmentReportEvidenceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchDisassociateAssessmentReportEvidenceResponse {
        try await self.client.execute(
            operation: "BatchDisassociateAssessmentReportEvidence", 
            path: "/assessments/{assessmentId}/batchDisassociateFromAssessmentReport", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Disassociates a list of evidence from an assessment report in Audit Manager.
    ///
    /// Parameters:
    ///   - assessmentId:  The identifier for the assessment.
    ///   - evidenceFolderId:  The identifier for the folder that the evidence is stored in.
    ///   - evidenceIds:  The list of evidence identifiers.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchDisassociateAssessmentReportEvidence(
        assessmentId: String,
        evidenceFolderId: String,
        evidenceIds: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchDisassociateAssessmentReportEvidenceResponse {
        let input = BatchDisassociateAssessmentReportEvidenceRequest(
            assessmentId: assessmentId, 
            evidenceFolderId: evidenceFolderId, 
            evidenceIds: evidenceIds
        )
        return try await self.batchDisassociateAssessmentReportEvidence(input, logger: logger)
    }

    /// Adds one or more pieces of evidence to a control in an Audit Manager assessment.  You can import manual evidence from any S3 bucket by specifying the S3 URI of the object. You can also upload a file from your browser, or enter plain text in response to a risk assessment question.  The following restrictions apply to this action:    manualEvidence can be only one of the following: evidenceFileName, s3ResourcePath, or textResponse    Maximum size of an individual evidence file: 100 MB   Number of daily manual evidence uploads per control: 100   Supported file formats: See Supported file types for manual evidence in the Audit Manager User Guide    For more information about Audit Manager service restrictions, see Quotas and restrictions for Audit Manager.
    @Sendable
    @inlinable
    public func batchImportEvidenceToAssessmentControl(_ input: BatchImportEvidenceToAssessmentControlRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchImportEvidenceToAssessmentControlResponse {
        try await self.client.execute(
            operation: "BatchImportEvidenceToAssessmentControl", 
            path: "/assessments/{assessmentId}/controlSets/{controlSetId}/controls/{controlId}/evidence", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds one or more pieces of evidence to a control in an Audit Manager assessment.  You can import manual evidence from any S3 bucket by specifying the S3 URI of the object. You can also upload a file from your browser, or enter plain text in response to a risk assessment question.  The following restrictions apply to this action:    manualEvidence can be only one of the following: evidenceFileName, s3ResourcePath, or textResponse    Maximum size of an individual evidence file: 100 MB   Number of daily manual evidence uploads per control: 100   Supported file formats: See Supported file types for manual evidence in the Audit Manager User Guide    For more information about Audit Manager service restrictions, see Quotas and restrictions for Audit Manager.
    ///
    /// Parameters:
    ///   - assessmentId:  The identifier for the assessment.
    ///   - controlId:  The identifier for the control.
    ///   - controlSetId:  The identifier for the control set.
    ///   - manualEvidence:  The list of manual evidence objects.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchImportEvidenceToAssessmentControl(
        assessmentId: String,
        controlId: String,
        controlSetId: String,
        manualEvidence: [ManualEvidence],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchImportEvidenceToAssessmentControlResponse {
        let input = BatchImportEvidenceToAssessmentControlRequest(
            assessmentId: assessmentId, 
            controlId: controlId, 
            controlSetId: controlSetId, 
            manualEvidence: manualEvidence
        )
        return try await self.batchImportEvidenceToAssessmentControl(input, logger: logger)
    }

    ///  Creates an assessment in Audit Manager.
    @Sendable
    @inlinable
    public func createAssessment(_ input: CreateAssessmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAssessmentResponse {
        try await self.client.execute(
            operation: "CreateAssessment", 
            path: "/assessments", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates an assessment in Audit Manager.
    ///
    /// Parameters:
    ///   - assessmentReportsDestination:  The assessment report storage destination for the assessment that's being created.
    ///   - description:  The optional description of the assessment to be created.
    ///   - frameworkId:  The identifier for the framework that the assessment will be created from.
    ///   - name:  The name of the assessment to be created.
    ///   - roles:  The list of roles for the assessment.
    ///   - scope: 
    ///   - tags:  The tags that are associated with the assessment.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAssessment(
        assessmentReportsDestination: AssessmentReportsDestination,
        description: String? = nil,
        frameworkId: String,
        name: String,
        roles: [Role],
        scope: Scope,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAssessmentResponse {
        let input = CreateAssessmentRequest(
            assessmentReportsDestination: assessmentReportsDestination, 
            description: description, 
            frameworkId: frameworkId, 
            name: name, 
            roles: roles, 
            scope: scope, 
            tags: tags
        )
        return try await self.createAssessment(input, logger: logger)
    }

    ///  Creates a custom framework in Audit Manager.
    @Sendable
    @inlinable
    public func createAssessmentFramework(_ input: CreateAssessmentFrameworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAssessmentFrameworkResponse {
        try await self.client.execute(
            operation: "CreateAssessmentFramework", 
            path: "/assessmentFrameworks", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates a custom framework in Audit Manager.
    ///
    /// Parameters:
    ///   - complianceType:  The compliance type that the new custom framework supports, such as CIS or HIPAA.
    ///   - controlSets:  The control sets that are associated with the framework.
    ///   - description:  An optional description for the new custom framework.
    ///   - name:  The name of the new custom framework.
    ///   - tags:  The tags that are associated with the framework.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAssessmentFramework(
        complianceType: String? = nil,
        controlSets: [CreateAssessmentFrameworkControlSet],
        description: String? = nil,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAssessmentFrameworkResponse {
        let input = CreateAssessmentFrameworkRequest(
            complianceType: complianceType, 
            controlSets: controlSets, 
            description: description, 
            name: name, 
            tags: tags
        )
        return try await self.createAssessmentFramework(input, logger: logger)
    }

    ///  Creates an assessment report for the specified assessment.
    @Sendable
    @inlinable
    public func createAssessmentReport(_ input: CreateAssessmentReportRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAssessmentReportResponse {
        try await self.client.execute(
            operation: "CreateAssessmentReport", 
            path: "/assessments/{assessmentId}/reports", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates an assessment report for the specified assessment.
    ///
    /// Parameters:
    ///   - assessmentId:  The identifier for the assessment.
    ///   - description:  The description of the assessment report.
    ///   - name:  The name of the new assessment report.
    ///   - queryStatement: A SQL statement that represents an evidence finder query. Provide this parameter when you want to generate an assessment report from the results of an evidence finder search query. When you use this parameter, Audit Manager generates a one-time report using only the evidence from the query output. This report does not include any assessment evidence that was manually added to a report using the console, or associated with a report using the API.  To use this parameter, the enablementStatus of evidence finder must be ENABLED.  For examples and help resolving queryStatement validation exceptions, see Troubleshooting evidence finder issues in the Audit Manager User Guide.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAssessmentReport(
        assessmentId: String,
        description: String? = nil,
        name: String,
        queryStatement: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAssessmentReportResponse {
        let input = CreateAssessmentReportRequest(
            assessmentId: assessmentId, 
            description: description, 
            name: name, 
            queryStatement: queryStatement
        )
        return try await self.createAssessmentReport(input, logger: logger)
    }

    ///  Creates a new custom control in Audit Manager.
    @Sendable
    @inlinable
    public func createControl(_ input: CreateControlRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateControlResponse {
        try await self.client.execute(
            operation: "CreateControl", 
            path: "/controls", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates a new custom control in Audit Manager.
    ///
    /// Parameters:
    ///   - actionPlanInstructions:  The recommended actions to carry out if the control isn't fulfilled.
    ///   - actionPlanTitle:  The title of the action plan for remediating the control.
    ///   - controlMappingSources:  The data mapping sources for the control.
    ///   - description:  The description of the control.
    ///   - name:  The name of the control.
    ///   - tags:  The tags that are associated with the control.
    ///   - testingInformation:  The steps to follow to determine if the control is satisfied.
    ///   - logger: Logger use during operation
    @inlinable
    public func createControl(
        actionPlanInstructions: String? = nil,
        actionPlanTitle: String? = nil,
        controlMappingSources: [CreateControlMappingSource],
        description: String? = nil,
        name: String,
        tags: [String: String]? = nil,
        testingInformation: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateControlResponse {
        let input = CreateControlRequest(
            actionPlanInstructions: actionPlanInstructions, 
            actionPlanTitle: actionPlanTitle, 
            controlMappingSources: controlMappingSources, 
            description: description, 
            name: name, 
            tags: tags, 
            testingInformation: testingInformation
        )
        return try await self.createControl(input, logger: logger)
    }

    ///  Deletes an assessment in Audit Manager.
    @Sendable
    @inlinable
    public func deleteAssessment(_ input: DeleteAssessmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAssessmentResponse {
        try await self.client.execute(
            operation: "DeleteAssessment", 
            path: "/assessments/{assessmentId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes an assessment in Audit Manager.
    ///
    /// Parameters:
    ///   - assessmentId:  The identifier for the assessment.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAssessment(
        assessmentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAssessmentResponse {
        let input = DeleteAssessmentRequest(
            assessmentId: assessmentId
        )
        return try await self.deleteAssessment(input, logger: logger)
    }

    ///  Deletes a custom framework in Audit Manager.
    @Sendable
    @inlinable
    public func deleteAssessmentFramework(_ input: DeleteAssessmentFrameworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAssessmentFrameworkResponse {
        try await self.client.execute(
            operation: "DeleteAssessmentFramework", 
            path: "/assessmentFrameworks/{frameworkId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes a custom framework in Audit Manager.
    ///
    /// Parameters:
    ///   - frameworkId:  The identifier for the custom framework.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAssessmentFramework(
        frameworkId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAssessmentFrameworkResponse {
        let input = DeleteAssessmentFrameworkRequest(
            frameworkId: frameworkId
        )
        return try await self.deleteAssessmentFramework(input, logger: logger)
    }

    ///  Deletes a share request for a custom framework in Audit Manager.
    @Sendable
    @inlinable
    public func deleteAssessmentFrameworkShare(_ input: DeleteAssessmentFrameworkShareRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAssessmentFrameworkShareResponse {
        try await self.client.execute(
            operation: "DeleteAssessmentFrameworkShare", 
            path: "/assessmentFrameworkShareRequests/{requestId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes a share request for a custom framework in Audit Manager.
    ///
    /// Parameters:
    ///   - requestId: The unique identifier for the share request to be deleted.
    ///   - requestType: Specifies whether the share request is a sent request or a received request.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAssessmentFrameworkShare(
        requestId: String,
        requestType: ShareRequestType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAssessmentFrameworkShareResponse {
        let input = DeleteAssessmentFrameworkShareRequest(
            requestId: requestId, 
            requestType: requestType
        )
        return try await self.deleteAssessmentFrameworkShare(input, logger: logger)
    }

    /// Deletes an assessment report in Audit Manager.  When you run the DeleteAssessmentReport operation, Audit Manager attempts to delete the following data:   The specified assessment report that’s stored in your S3 bucket   The associated metadata that’s stored in Audit Manager   If Audit Manager can’t access the assessment report in your S3 bucket, the report isn’t deleted. In this event, the DeleteAssessmentReport operation doesn’t fail. Instead, it proceeds to delete the associated metadata only. You must then delete the assessment report from the S3 bucket yourself.  This scenario happens when Audit Manager receives a 403 (Forbidden) or 404 (Not Found) error from Amazon S3. To avoid this, make sure that your S3 bucket is available, and that you configured the correct permissions for Audit Manager to delete resources in your S3 bucket. For an example permissions policy that you can use, see Assessment report destination permissions in the Audit Manager User Guide. For information about the issues that could cause a 403 (Forbidden) or 404 (Not Found) error from Amazon S3, see List of Error Codes in the Amazon Simple Storage Service API Reference.
    @Sendable
    @inlinable
    public func deleteAssessmentReport(_ input: DeleteAssessmentReportRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAssessmentReportResponse {
        try await self.client.execute(
            operation: "DeleteAssessmentReport", 
            path: "/assessments/{assessmentId}/reports/{assessmentReportId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an assessment report in Audit Manager.  When you run the DeleteAssessmentReport operation, Audit Manager attempts to delete the following data:   The specified assessment report that’s stored in your S3 bucket   The associated metadata that’s stored in Audit Manager   If Audit Manager can’t access the assessment report in your S3 bucket, the report isn’t deleted. In this event, the DeleteAssessmentReport operation doesn’t fail. Instead, it proceeds to delete the associated metadata only. You must then delete the assessment report from the S3 bucket yourself.  This scenario happens when Audit Manager receives a 403 (Forbidden) or 404 (Not Found) error from Amazon S3. To avoid this, make sure that your S3 bucket is available, and that you configured the correct permissions for Audit Manager to delete resources in your S3 bucket. For an example permissions policy that you can use, see Assessment report destination permissions in the Audit Manager User Guide. For information about the issues that could cause a 403 (Forbidden) or 404 (Not Found) error from Amazon S3, see List of Error Codes in the Amazon Simple Storage Service API Reference.
    ///
    /// Parameters:
    ///   - assessmentId:  The unique identifier for the assessment.
    ///   - assessmentReportId:  The unique identifier for the assessment report.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAssessmentReport(
        assessmentId: String,
        assessmentReportId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAssessmentReportResponse {
        let input = DeleteAssessmentReportRequest(
            assessmentId: assessmentId, 
            assessmentReportId: assessmentReportId
        )
        return try await self.deleteAssessmentReport(input, logger: logger)
    }

    ///  Deletes a custom control in Audit Manager.   When you invoke this operation, the custom control is deleted from any frameworks or assessments that it’s currently part of. As a result, Audit Manager will stop collecting evidence for that custom control in all of your assessments. This includes assessments that you previously created before you deleted the custom control.
    @Sendable
    @inlinable
    public func deleteControl(_ input: DeleteControlRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteControlResponse {
        try await self.client.execute(
            operation: "DeleteControl", 
            path: "/controls/{controlId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes a custom control in Audit Manager.   When you invoke this operation, the custom control is deleted from any frameworks or assessments that it’s currently part of. As a result, Audit Manager will stop collecting evidence for that custom control in all of your assessments. This includes assessments that you previously created before you deleted the custom control.
    ///
    /// Parameters:
    ///   - controlId:  The unique identifier for the control.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteControl(
        controlId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteControlResponse {
        let input = DeleteControlRequest(
            controlId: controlId
        )
        return try await self.deleteControl(input, logger: logger)
    }

    ///  Deregisters an account in Audit Manager.   Before you deregister, you can use the UpdateSettings API operation to set your preferred data retention policy. By default, Audit Manager retains your data. If you want to delete your data, you can use the DeregistrationPolicy attribute to request the deletion of your data.  For more information about data retention, see Data Protection in the Audit Manager User Guide.
    @Sendable
    @inlinable
    public func deregisterAccount(_ input: DeregisterAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeregisterAccountResponse {
        try await self.client.execute(
            operation: "DeregisterAccount", 
            path: "/account/deregisterAccount", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deregisters an account in Audit Manager.   Before you deregister, you can use the UpdateSettings API operation to set your preferred data retention policy. By default, Audit Manager retains your data. If you want to delete your data, you can use the DeregistrationPolicy attribute to request the deletion of your data.  For more information about data retention, see Data Protection in the Audit Manager User Guide.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func deregisterAccount(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeregisterAccountResponse {
        let input = DeregisterAccountRequest(
        )
        return try await self.deregisterAccount(input, logger: logger)
    }

    /// Removes the specified Amazon Web Services account as a delegated administrator for Audit Manager.  When you remove a delegated administrator from your Audit Manager settings, you continue to have access to the evidence that you previously collected under that account. This is also the case when you deregister a delegated administrator from Organizations. However, Audit Manager stops collecting and attaching evidence to that delegated administrator account moving forward.  Keep in mind the following cleanup task if you use evidence finder: Before you use your management account to remove a delegated administrator, make sure that the current delegated administrator account signs in to Audit Manager and disables evidence finder first. Disabling evidence finder automatically deletes the event data store that was created in their account when they enabled evidence finder. If this task isn’t completed, the event data store remains in their account. In this case, we recommend that the original delegated administrator goes to CloudTrail Lake and manually deletes the event data store. This cleanup task is necessary to ensure that you don't end up with multiple event data stores. Audit Manager ignores an unused event data store after you remove or change a delegated administrator account. However, the unused event data store continues to incur storage costs from CloudTrail Lake if you don't delete it.  When you deregister a delegated administrator account for Audit Manager, the data for that account isn’t deleted. If you want to delete resource data for a delegated administrator account, you must perform that task separately before you deregister the account. Either, you can do this in the Audit Manager console. Or, you can use one of the delete API operations that are provided by Audit Manager.  To delete your Audit Manager resource data, see the following instructions:     DeleteAssessment (see also: Deleting an assessment in the Audit Manager User Guide)    DeleteAssessmentFramework (see also: Deleting a custom framework in the Audit Manager User Guide)    DeleteAssessmentFrameworkShare (see also: Deleting a share request in the Audit Manager User Guide)    DeleteAssessmentReport (see also: Deleting an assessment report in the Audit Manager User Guide)    DeleteControl (see also: Deleting a custom control in the Audit Manager User Guide)   At this time, Audit Manager doesn't provide an option to delete evidence for a specific delegated administrator. Instead, when your management account deregisters Audit Manager, we perform a cleanup for the current delegated administrator account at the time of deregistration.
    @Sendable
    @inlinable
    public func deregisterOrganizationAdminAccount(_ input: DeregisterOrganizationAdminAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeregisterOrganizationAdminAccountResponse {
        try await self.client.execute(
            operation: "DeregisterOrganizationAdminAccount", 
            path: "/account/deregisterOrganizationAdminAccount", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the specified Amazon Web Services account as a delegated administrator for Audit Manager.  When you remove a delegated administrator from your Audit Manager settings, you continue to have access to the evidence that you previously collected under that account. This is also the case when you deregister a delegated administrator from Organizations. However, Audit Manager stops collecting and attaching evidence to that delegated administrator account moving forward.  Keep in mind the following cleanup task if you use evidence finder: Before you use your management account to remove a delegated administrator, make sure that the current delegated administrator account signs in to Audit Manager and disables evidence finder first. Disabling evidence finder automatically deletes the event data store that was created in their account when they enabled evidence finder. If this task isn’t completed, the event data store remains in their account. In this case, we recommend that the original delegated administrator goes to CloudTrail Lake and manually deletes the event data store. This cleanup task is necessary to ensure that you don't end up with multiple event data stores. Audit Manager ignores an unused event data store after you remove or change a delegated administrator account. However, the unused event data store continues to incur storage costs from CloudTrail Lake if you don't delete it.  When you deregister a delegated administrator account for Audit Manager, the data for that account isn’t deleted. If you want to delete resource data for a delegated administrator account, you must perform that task separately before you deregister the account. Either, you can do this in the Audit Manager console. Or, you can use one of the delete API operations that are provided by Audit Manager.  To delete your Audit Manager resource data, see the following instructions:     DeleteAssessment (see also: Deleting an assessment in the Audit Manager User Guide)    DeleteAssessmentFramework (see also: Deleting a custom framework in the Audit Manager User Guide)    DeleteAssessmentFrameworkShare (see also: Deleting a share request in the Audit Manager User Guide)    DeleteAssessmentReport (see also: Deleting an assessment report in the Audit Manager User Guide)    DeleteControl (see also: Deleting a custom control in the Audit Manager User Guide)   At this time, Audit Manager doesn't provide an option to delete evidence for a specific delegated administrator. Instead, when your management account deregisters Audit Manager, we perform a cleanup for the current delegated administrator account at the time of deregistration.
    ///
    /// Parameters:
    ///   - adminAccountId:  The identifier for the administrator account.
    ///   - logger: Logger use during operation
    @inlinable
    public func deregisterOrganizationAdminAccount(
        adminAccountId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeregisterOrganizationAdminAccountResponse {
        let input = DeregisterOrganizationAdminAccountRequest(
            adminAccountId: adminAccountId
        )
        return try await self.deregisterOrganizationAdminAccount(input, logger: logger)
    }

    ///  Disassociates an evidence folder from the specified assessment report in Audit Manager.
    @Sendable
    @inlinable
    public func disassociateAssessmentReportEvidenceFolder(_ input: DisassociateAssessmentReportEvidenceFolderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateAssessmentReportEvidenceFolderResponse {
        try await self.client.execute(
            operation: "DisassociateAssessmentReportEvidenceFolder", 
            path: "/assessments/{assessmentId}/disassociateFromAssessmentReport", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Disassociates an evidence folder from the specified assessment report in Audit Manager.
    ///
    /// Parameters:
    ///   - assessmentId:  The unique identifier for the assessment.
    ///   - evidenceFolderId:  The unique identifier for the folder that the evidence is stored in.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateAssessmentReportEvidenceFolder(
        assessmentId: String,
        evidenceFolderId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateAssessmentReportEvidenceFolderResponse {
        let input = DisassociateAssessmentReportEvidenceFolderRequest(
            assessmentId: assessmentId, 
            evidenceFolderId: evidenceFolderId
        )
        return try await self.disassociateAssessmentReportEvidenceFolder(input, logger: logger)
    }

    ///  Gets the registration status of an account in Audit Manager.
    @Sendable
    @inlinable
    public func getAccountStatus(_ input: GetAccountStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAccountStatusResponse {
        try await self.client.execute(
            operation: "GetAccountStatus", 
            path: "/account/status", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Gets the registration status of an account in Audit Manager.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getAccountStatus(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAccountStatusResponse {
        let input = GetAccountStatusRequest(
        )
        return try await self.getAccountStatus(input, logger: logger)
    }

    /// Gets information about a specified assessment.
    @Sendable
    @inlinable
    public func getAssessment(_ input: GetAssessmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAssessmentResponse {
        try await self.client.execute(
            operation: "GetAssessment", 
            path: "/assessments/{assessmentId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a specified assessment.
    ///
    /// Parameters:
    ///   - assessmentId: The unique identifier for the assessment.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAssessment(
        assessmentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAssessmentResponse {
        let input = GetAssessmentRequest(
            assessmentId: assessmentId
        )
        return try await self.getAssessment(input, logger: logger)
    }

    /// Gets information about a specified framework.
    @Sendable
    @inlinable
    public func getAssessmentFramework(_ input: GetAssessmentFrameworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAssessmentFrameworkResponse {
        try await self.client.execute(
            operation: "GetAssessmentFramework", 
            path: "/assessmentFrameworks/{frameworkId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about a specified framework.
    ///
    /// Parameters:
    ///   - frameworkId:  The identifier for the framework.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAssessmentFramework(
        frameworkId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAssessmentFrameworkResponse {
        let input = GetAssessmentFrameworkRequest(
            frameworkId: frameworkId
        )
        return try await self.getAssessmentFramework(input, logger: logger)
    }

    ///  Gets the URL of an assessment report in Audit Manager.
    @Sendable
    @inlinable
    public func getAssessmentReportUrl(_ input: GetAssessmentReportUrlRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAssessmentReportUrlResponse {
        try await self.client.execute(
            operation: "GetAssessmentReportUrl", 
            path: "/assessments/{assessmentId}/reports/{assessmentReportId}/url", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Gets the URL of an assessment report in Audit Manager.
    ///
    /// Parameters:
    ///   - assessmentId:  The unique identifier for the assessment.
    ///   - assessmentReportId:  The unique identifier for the assessment report.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAssessmentReportUrl(
        assessmentId: String,
        assessmentReportId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAssessmentReportUrlResponse {
        let input = GetAssessmentReportUrlRequest(
            assessmentId: assessmentId, 
            assessmentReportId: assessmentReportId
        )
        return try await self.getAssessmentReportUrl(input, logger: logger)
    }

    ///  Gets a list of changelogs from Audit Manager.
    @Sendable
    @inlinable
    public func getChangeLogs(_ input: GetChangeLogsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetChangeLogsResponse {
        try await self.client.execute(
            operation: "GetChangeLogs", 
            path: "/assessments/{assessmentId}/changelogs", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Gets a list of changelogs from Audit Manager.
    ///
    /// Parameters:
    ///   - assessmentId: The unique identifier for the assessment.
    ///   - controlId:  The unique identifier for the control.
    ///   - controlSetId:  The unique identifier for the control set.
    ///   - maxResults: Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken:  The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getChangeLogs(
        assessmentId: String,
        controlId: String? = nil,
        controlSetId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetChangeLogsResponse {
        let input = GetChangeLogsRequest(
            assessmentId: assessmentId, 
            controlId: controlId, 
            controlSetId: controlSetId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getChangeLogs(input, logger: logger)
    }

    ///  Gets information about a specified control.
    @Sendable
    @inlinable
    public func getControl(_ input: GetControlRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetControlResponse {
        try await self.client.execute(
            operation: "GetControl", 
            path: "/controls/{controlId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Gets information about a specified control.
    ///
    /// Parameters:
    ///   - controlId:  The identifier for the control.
    ///   - logger: Logger use during operation
    @inlinable
    public func getControl(
        controlId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetControlResponse {
        let input = GetControlRequest(
            controlId: controlId
        )
        return try await self.getControl(input, logger: logger)
    }

    ///  Gets a list of delegations from an audit owner to a delegate.
    @Sendable
    @inlinable
    public func getDelegations(_ input: GetDelegationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDelegationsResponse {
        try await self.client.execute(
            operation: "GetDelegations", 
            path: "/delegations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Gets a list of delegations from an audit owner to a delegate.
    ///
    /// Parameters:
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken:  The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDelegations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDelegationsResponse {
        let input = GetDelegationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getDelegations(input, logger: logger)
    }

    ///  Gets information about a specified evidence item.
    @Sendable
    @inlinable
    public func getEvidence(_ input: GetEvidenceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEvidenceResponse {
        try await self.client.execute(
            operation: "GetEvidence", 
            path: "/assessments/{assessmentId}/controlSets/{controlSetId}/evidenceFolders/{evidenceFolderId}/evidence/{evidenceId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Gets information about a specified evidence item.
    ///
    /// Parameters:
    ///   - assessmentId:  The unique identifier for the assessment.
    ///   - controlSetId:  The unique identifier for the control set.
    ///   - evidenceFolderId:  The unique identifier for the folder that the evidence is stored in.
    ///   - evidenceId:  The unique identifier for the evidence.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEvidence(
        assessmentId: String,
        controlSetId: String,
        evidenceFolderId: String,
        evidenceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEvidenceResponse {
        let input = GetEvidenceRequest(
            assessmentId: assessmentId, 
            controlSetId: controlSetId, 
            evidenceFolderId: evidenceFolderId, 
            evidenceId: evidenceId
        )
        return try await self.getEvidence(input, logger: logger)
    }

    ///  Gets all evidence from a specified evidence folder in Audit Manager.
    @Sendable
    @inlinable
    public func getEvidenceByEvidenceFolder(_ input: GetEvidenceByEvidenceFolderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEvidenceByEvidenceFolderResponse {
        try await self.client.execute(
            operation: "GetEvidenceByEvidenceFolder", 
            path: "/assessments/{assessmentId}/controlSets/{controlSetId}/evidenceFolders/{evidenceFolderId}/evidence", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Gets all evidence from a specified evidence folder in Audit Manager.
    ///
    /// Parameters:
    ///   - assessmentId:  The identifier for the assessment.
    ///   - controlSetId:  The identifier for the control set.
    ///   - evidenceFolderId:  The unique identifier for the folder that the evidence is stored in.
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken:  The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEvidenceByEvidenceFolder(
        assessmentId: String,
        controlSetId: String,
        evidenceFolderId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEvidenceByEvidenceFolderResponse {
        let input = GetEvidenceByEvidenceFolderRequest(
            assessmentId: assessmentId, 
            controlSetId: controlSetId, 
            evidenceFolderId: evidenceFolderId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getEvidenceByEvidenceFolder(input, logger: logger)
    }

    /// Creates a presigned Amazon S3 URL that can be used to upload a file as manual evidence. For instructions on how to use this operation, see Upload a file from your browser  in the Audit Manager User Guide. The following restrictions apply to this operation:   Maximum size of an individual evidence file: 100 MB   Number of daily manual evidence uploads per control: 100   Supported file formats: See Supported file types for manual evidence in the Audit Manager User Guide    For more information about Audit Manager service restrictions, see Quotas and restrictions for Audit Manager.
    @Sendable
    @inlinable
    public func getEvidenceFileUploadUrl(_ input: GetEvidenceFileUploadUrlRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEvidenceFileUploadUrlResponse {
        try await self.client.execute(
            operation: "GetEvidenceFileUploadUrl", 
            path: "/evidenceFileUploadUrl", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a presigned Amazon S3 URL that can be used to upload a file as manual evidence. For instructions on how to use this operation, see Upload a file from your browser  in the Audit Manager User Guide. The following restrictions apply to this operation:   Maximum size of an individual evidence file: 100 MB   Number of daily manual evidence uploads per control: 100   Supported file formats: See Supported file types for manual evidence in the Audit Manager User Guide    For more information about Audit Manager service restrictions, see Quotas and restrictions for Audit Manager.
    ///
    /// Parameters:
    ///   - fileName: The file that you want to upload. For a list of supported file formats, see Supported file types for manual evidence in the Audit Manager User Guide.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEvidenceFileUploadUrl(
        fileName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEvidenceFileUploadUrlResponse {
        let input = GetEvidenceFileUploadUrlRequest(
            fileName: fileName
        )
        return try await self.getEvidenceFileUploadUrl(input, logger: logger)
    }

    ///  Gets an evidence folder from a specified assessment in Audit Manager.
    @Sendable
    @inlinable
    public func getEvidenceFolder(_ input: GetEvidenceFolderRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEvidenceFolderResponse {
        try await self.client.execute(
            operation: "GetEvidenceFolder", 
            path: "/assessments/{assessmentId}/controlSets/{controlSetId}/evidenceFolders/{evidenceFolderId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Gets an evidence folder from a specified assessment in Audit Manager.
    ///
    /// Parameters:
    ///   - assessmentId:  The unique identifier for the assessment.
    ///   - controlSetId:  The unique identifier for the control set.
    ///   - evidenceFolderId:  The unique identifier for the folder that the evidence is stored in.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEvidenceFolder(
        assessmentId: String,
        controlSetId: String,
        evidenceFolderId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEvidenceFolderResponse {
        let input = GetEvidenceFolderRequest(
            assessmentId: assessmentId, 
            controlSetId: controlSetId, 
            evidenceFolderId: evidenceFolderId
        )
        return try await self.getEvidenceFolder(input, logger: logger)
    }

    ///  Gets the evidence folders from a specified assessment in Audit Manager.
    @Sendable
    @inlinable
    public func getEvidenceFoldersByAssessment(_ input: GetEvidenceFoldersByAssessmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEvidenceFoldersByAssessmentResponse {
        try await self.client.execute(
            operation: "GetEvidenceFoldersByAssessment", 
            path: "/assessments/{assessmentId}/evidenceFolders", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Gets the evidence folders from a specified assessment in Audit Manager.
    ///
    /// Parameters:
    ///   - assessmentId:  The unique identifier for the assessment.
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken:  The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEvidenceFoldersByAssessment(
        assessmentId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEvidenceFoldersByAssessmentResponse {
        let input = GetEvidenceFoldersByAssessmentRequest(
            assessmentId: assessmentId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getEvidenceFoldersByAssessment(input, logger: logger)
    }

    ///  Gets a list of evidence folders that are associated with a specified control in an Audit Manager assessment.
    @Sendable
    @inlinable
    public func getEvidenceFoldersByAssessmentControl(_ input: GetEvidenceFoldersByAssessmentControlRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEvidenceFoldersByAssessmentControlResponse {
        try await self.client.execute(
            operation: "GetEvidenceFoldersByAssessmentControl", 
            path: "/assessments/{assessmentId}/evidenceFolders-by-assessment-control/{controlSetId}/{controlId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Gets a list of evidence folders that are associated with a specified control in an Audit Manager assessment.
    ///
    /// Parameters:
    ///   - assessmentId:  The identifier for the assessment.
    ///   - controlId:  The identifier for the control.
    ///   - controlSetId:  The identifier for the control set.
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken:  The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEvidenceFoldersByAssessmentControl(
        assessmentId: String,
        controlId: String,
        controlSetId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEvidenceFoldersByAssessmentControlResponse {
        let input = GetEvidenceFoldersByAssessmentControlRequest(
            assessmentId: assessmentId, 
            controlId: controlId, 
            controlSetId: controlSetId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getEvidenceFoldersByAssessmentControl(input, logger: logger)
    }

    /// Gets the latest analytics data for all your current active assessments.
    @Sendable
    @inlinable
    public func getInsights(_ input: GetInsightsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetInsightsResponse {
        try await self.client.execute(
            operation: "GetInsights", 
            path: "/insights", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the latest analytics data for all your current active assessments.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getInsights(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetInsightsResponse {
        let input = GetInsightsRequest(
        )
        return try await self.getInsights(input, logger: logger)
    }

    /// Gets the latest analytics data for a specific active assessment.
    @Sendable
    @inlinable
    public func getInsightsByAssessment(_ input: GetInsightsByAssessmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetInsightsByAssessmentResponse {
        try await self.client.execute(
            operation: "GetInsightsByAssessment", 
            path: "/insights/assessments/{assessmentId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the latest analytics data for a specific active assessment.
    ///
    /// Parameters:
    ///   - assessmentId: The unique identifier for the assessment.
    ///   - logger: Logger use during operation
    @inlinable
    public func getInsightsByAssessment(
        assessmentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetInsightsByAssessmentResponse {
        let input = GetInsightsByAssessmentRequest(
            assessmentId: assessmentId
        )
        return try await self.getInsightsByAssessment(input, logger: logger)
    }

    ///  Gets the name of the delegated Amazon Web Services administrator account for a specified organization.
    @Sendable
    @inlinable
    public func getOrganizationAdminAccount(_ input: GetOrganizationAdminAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetOrganizationAdminAccountResponse {
        try await self.client.execute(
            operation: "GetOrganizationAdminAccount", 
            path: "/account/organizationAdminAccount", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Gets the name of the delegated Amazon Web Services administrator account for a specified organization.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getOrganizationAdminAccount(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetOrganizationAdminAccountResponse {
        let input = GetOrganizationAdminAccountRequest(
        )
        return try await self.getOrganizationAdminAccount(input, logger: logger)
    }

    /// Gets a list of the Amazon Web Services services from which Audit Manager can collect evidence.  Audit Manager defines which Amazon Web Services services are in scope for an assessment. Audit Manager infers this scope by examining the assessment’s controls and their data sources, and then mapping this information to one or more of the corresponding Amazon Web Services services that are in this list.  For information about why it's no longer possible to specify services in scope manually, see I can't edit the services in scope for my assessment in the Troubleshooting section of the Audit Manager user guide.
    @Sendable
    @inlinable
    public func getServicesInScope(_ input: GetServicesInScopeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetServicesInScopeResponse {
        try await self.client.execute(
            operation: "GetServicesInScope", 
            path: "/services", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a list of the Amazon Web Services services from which Audit Manager can collect evidence.  Audit Manager defines which Amazon Web Services services are in scope for an assessment. Audit Manager infers this scope by examining the assessment’s controls and their data sources, and then mapping this information to one or more of the corresponding Amazon Web Services services that are in this list.  For information about why it's no longer possible to specify services in scope manually, see I can't edit the services in scope for my assessment in the Troubleshooting section of the Audit Manager user guide.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getServicesInScope(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetServicesInScopeResponse {
        let input = GetServicesInScopeRequest(
        )
        return try await self.getServicesInScope(input, logger: logger)
    }

    ///  Gets the settings for a specified Amazon Web Services account.
    @Sendable
    @inlinable
    public func getSettings(_ input: GetSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSettingsResponse {
        try await self.client.execute(
            operation: "GetSettings", 
            path: "/settings/{attribute}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Gets the settings for a specified Amazon Web Services account.
    ///
    /// Parameters:
    ///   - attribute:  The list of setting attribute enum values.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSettings(
        attribute: SettingAttribute,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSettingsResponse {
        let input = GetSettingsRequest(
            attribute: attribute
        )
        return try await self.getSettings(input, logger: logger)
    }

    /// Lists the latest analytics data for controls within a specific control domain and a specific active assessment.  Control insights are listed only if the control belongs to the control domain and assessment that was specified. Moreover, the control must have collected evidence on the lastUpdated date of controlInsightsByAssessment. If neither of these conditions are met, no data is listed for that control.
    @Sendable
    @inlinable
    public func listAssessmentControlInsightsByControlDomain(_ input: ListAssessmentControlInsightsByControlDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAssessmentControlInsightsByControlDomainResponse {
        try await self.client.execute(
            operation: "ListAssessmentControlInsightsByControlDomain", 
            path: "/insights/controls-by-assessment", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the latest analytics data for controls within a specific control domain and a specific active assessment.  Control insights are listed only if the control belongs to the control domain and assessment that was specified. Moreover, the control must have collected evidence on the lastUpdated date of controlInsightsByAssessment. If neither of these conditions are met, no data is listed for that control.
    ///
    /// Parameters:
    ///   - assessmentId: The unique identifier for the active assessment.
    ///   - controlDomainId: The unique identifier for the control domain.  Audit Manager supports the control domains that are provided by Amazon Web Services Control Catalog. For information about how to find a list of available control domains, see  ListDomains in the Amazon Web Services Control Catalog API Reference.
    ///   - maxResults: Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAssessmentControlInsightsByControlDomain(
        assessmentId: String,
        controlDomainId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAssessmentControlInsightsByControlDomainResponse {
        let input = ListAssessmentControlInsightsByControlDomainRequest(
            assessmentId: assessmentId, 
            controlDomainId: controlDomainId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAssessmentControlInsightsByControlDomain(input, logger: logger)
    }

    ///  Returns a list of sent or received share requests for custom frameworks in Audit Manager.
    @Sendable
    @inlinable
    public func listAssessmentFrameworkShareRequests(_ input: ListAssessmentFrameworkShareRequestsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAssessmentFrameworkShareRequestsResponse {
        try await self.client.execute(
            operation: "ListAssessmentFrameworkShareRequests", 
            path: "/assessmentFrameworkShareRequests", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Returns a list of sent or received share requests for custom frameworks in Audit Manager.
    ///
    /// Parameters:
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken:  The pagination token that's used to fetch the next set of results.
    ///   - requestType:  Specifies whether the share request is a sent request or a received request.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAssessmentFrameworkShareRequests(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        requestType: ShareRequestType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAssessmentFrameworkShareRequestsResponse {
        let input = ListAssessmentFrameworkShareRequestsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            requestType: requestType
        )
        return try await self.listAssessmentFrameworkShareRequests(input, logger: logger)
    }

    ///  Returns a list of the frameworks that are available in the Audit Manager framework library.
    @Sendable
    @inlinable
    public func listAssessmentFrameworks(_ input: ListAssessmentFrameworksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAssessmentFrameworksResponse {
        try await self.client.execute(
            operation: "ListAssessmentFrameworks", 
            path: "/assessmentFrameworks", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Returns a list of the frameworks that are available in the Audit Manager framework library.
    ///
    /// Parameters:
    ///   - frameworkType:  The type of framework, such as a standard framework or a custom framework.
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken:  The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAssessmentFrameworks(
        frameworkType: FrameworkType,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAssessmentFrameworksResponse {
        let input = ListAssessmentFrameworksRequest(
            frameworkType: frameworkType, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAssessmentFrameworks(input, logger: logger)
    }

    ///  Returns a list of assessment reports created in Audit Manager.
    @Sendable
    @inlinable
    public func listAssessmentReports(_ input: ListAssessmentReportsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAssessmentReportsResponse {
        try await self.client.execute(
            operation: "ListAssessmentReports", 
            path: "/assessmentReports", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Returns a list of assessment reports created in Audit Manager.
    ///
    /// Parameters:
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken:  The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAssessmentReports(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAssessmentReportsResponse {
        let input = ListAssessmentReportsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAssessmentReports(input, logger: logger)
    }

    ///  Returns a list of current and past assessments from Audit Manager.
    @Sendable
    @inlinable
    public func listAssessments(_ input: ListAssessmentsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAssessmentsResponse {
        try await self.client.execute(
            operation: "ListAssessments", 
            path: "/assessments", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Returns a list of current and past assessments from Audit Manager.
    ///
    /// Parameters:
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken:  The pagination token that's used to fetch the next set of results.
    ///   - status:  The current status of the assessment.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAssessments(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        status: AssessmentStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAssessmentsResponse {
        let input = ListAssessmentsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            status: status
        )
        return try await self.listAssessments(input, logger: logger)
    }

    /// Lists the latest analytics data for control domains across all of your active assessments.  Audit Manager supports the control domains that are provided by Amazon Web Services Control Catalog. For information about how to find a list of available control domains, see  ListDomains in the Amazon Web Services Control Catalog API Reference.  A control domain is listed only if at least one of the controls within that domain collected evidence on the lastUpdated date of controlDomainInsights. If this condition isn’t met, no data is listed for that control domain.
    @Sendable
    @inlinable
    public func listControlDomainInsights(_ input: ListControlDomainInsightsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListControlDomainInsightsResponse {
        try await self.client.execute(
            operation: "ListControlDomainInsights", 
            path: "/insights/control-domains", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the latest analytics data for control domains across all of your active assessments.  Audit Manager supports the control domains that are provided by Amazon Web Services Control Catalog. For information about how to find a list of available control domains, see  ListDomains in the Amazon Web Services Control Catalog API Reference.  A control domain is listed only if at least one of the controls within that domain collected evidence on the lastUpdated date of controlDomainInsights. If this condition isn’t met, no data is listed for that control domain.
    ///
    /// Parameters:
    ///   - maxResults: Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listControlDomainInsights(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListControlDomainInsightsResponse {
        let input = ListControlDomainInsightsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listControlDomainInsights(input, logger: logger)
    }

    /// Lists analytics data for control domains within a specified active assessment. Audit Manager supports the control domains that are provided by Amazon Web Services Control Catalog. For information about how to find a list of available control domains, see  ListDomains in the Amazon Web Services Control Catalog API Reference.  A control domain is listed only if at least one of the controls within that domain collected evidence on the lastUpdated date of controlDomainInsights. If this condition isn’t met, no data is listed for that domain.
    @Sendable
    @inlinable
    public func listControlDomainInsightsByAssessment(_ input: ListControlDomainInsightsByAssessmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListControlDomainInsightsByAssessmentResponse {
        try await self.client.execute(
            operation: "ListControlDomainInsightsByAssessment", 
            path: "/insights/control-domains-by-assessment", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists analytics data for control domains within a specified active assessment. Audit Manager supports the control domains that are provided by Amazon Web Services Control Catalog. For information about how to find a list of available control domains, see  ListDomains in the Amazon Web Services Control Catalog API Reference.  A control domain is listed only if at least one of the controls within that domain collected evidence on the lastUpdated date of controlDomainInsights. If this condition isn’t met, no data is listed for that domain.
    ///
    /// Parameters:
    ///   - assessmentId: The unique identifier for the active assessment.
    ///   - maxResults: Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listControlDomainInsightsByAssessment(
        assessmentId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListControlDomainInsightsByAssessmentResponse {
        let input = ListControlDomainInsightsByAssessmentRequest(
            assessmentId: assessmentId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listControlDomainInsightsByAssessment(input, logger: logger)
    }

    /// Lists the latest analytics data for controls within a specific control domain across all active assessments.  Control insights are listed only if the control belongs to the control domain that was specified and the control collected evidence on the lastUpdated date of controlInsightsMetadata. If neither of these conditions are met, no data is listed for that control.
    @Sendable
    @inlinable
    public func listControlInsightsByControlDomain(_ input: ListControlInsightsByControlDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListControlInsightsByControlDomainResponse {
        try await self.client.execute(
            operation: "ListControlInsightsByControlDomain", 
            path: "/insights/controls", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the latest analytics data for controls within a specific control domain across all active assessments.  Control insights are listed only if the control belongs to the control domain that was specified and the control collected evidence on the lastUpdated date of controlInsightsMetadata. If neither of these conditions are met, no data is listed for that control.
    ///
    /// Parameters:
    ///   - controlDomainId: The unique identifier for the control domain.  Audit Manager supports the control domains that are provided by Amazon Web Services Control Catalog. For information about how to find a list of available control domains, see  ListDomains in the Amazon Web Services Control Catalog API Reference.
    ///   - maxResults: Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listControlInsightsByControlDomain(
        controlDomainId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListControlInsightsByControlDomainResponse {
        let input = ListControlInsightsByControlDomainRequest(
            controlDomainId: controlDomainId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listControlInsightsByControlDomain(input, logger: logger)
    }

    ///  Returns a list of controls from Audit Manager.
    @Sendable
    @inlinable
    public func listControls(_ input: ListControlsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListControlsResponse {
        try await self.client.execute(
            operation: "ListControls", 
            path: "/controls", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Returns a list of controls from Audit Manager.
    ///
    /// Parameters:
    ///   - controlCatalogId: A filter that narrows the list of controls to a specific resource from the Amazon Web Services  Control Catalog.  To use this parameter, specify the ARN of the Control Catalog resource. You can specify either  a control domain, a control objective, or a common control. For information about how to find the ARNs for these resources, see  ListDomains ,  ListObjectives , and  ListCommonControls .  You can only filter by one Control Catalog resource at a time.  Specifying multiple resource ARNs isn’t currently supported. If you want to filter by more  than one ARN, we recommend that you run the ListControls operation separately  for each ARN.   Alternatively, specify UNCATEGORIZED to list controls that aren't mapped to a Control Catalog resource. For example, this operation might return a list of  custom controls that don't belong to any control domain or control objective.
    ///   - controlType: A filter that narrows the list of controls to a specific type.
    ///   - maxResults: The maximum number of results on a page or for an API request call.
    ///   - nextToken: The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listControls(
        controlCatalogId: String? = nil,
        controlType: ControlType,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListControlsResponse {
        let input = ListControlsRequest(
            controlCatalogId: controlCatalogId, 
            controlType: controlType, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listControls(input, logger: logger)
    }

    /// Returns a list of keywords that are pre-mapped to the specified control data source.
    @Sendable
    @inlinable
    public func listKeywordsForDataSource(_ input: ListKeywordsForDataSourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListKeywordsForDataSourceResponse {
        try await self.client.execute(
            operation: "ListKeywordsForDataSource", 
            path: "/dataSourceKeywords", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of keywords that are pre-mapped to the specified control data source.
    ///
    /// Parameters:
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken:  The pagination token that's used to fetch the next set of results.
    ///   - source: The control mapping data source that the keywords apply to.
    ///   - logger: Logger use during operation
    @inlinable
    public func listKeywordsForDataSource(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        source: DataSourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListKeywordsForDataSourceResponse {
        let input = ListKeywordsForDataSourceRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            source: source
        )
        return try await self.listKeywordsForDataSource(input, logger: logger)
    }

    ///  Returns a list of all Audit Manager notifications.
    @Sendable
    @inlinable
    public func listNotifications(_ input: ListNotificationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListNotificationsResponse {
        try await self.client.execute(
            operation: "ListNotifications", 
            path: "/notifications", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Returns a list of all Audit Manager notifications.
    ///
    /// Parameters:
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - nextToken:  The pagination token that's used to fetch the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listNotifications(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListNotificationsResponse {
        let input = ListNotificationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listNotifications(input, logger: logger)
    }

    ///  Returns a list of tags for the specified resource in Audit Manager.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Returns a list of tags for the specified resource in Audit Manager.
    ///
    /// Parameters:
    ///   - resourceArn:  The Amazon Resource Name (ARN) of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    ///  Enables Audit Manager for the specified Amazon Web Services account.
    @Sendable
    @inlinable
    public func registerAccount(_ input: RegisterAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RegisterAccountResponse {
        try await self.client.execute(
            operation: "RegisterAccount", 
            path: "/account/registerAccount", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Enables Audit Manager for the specified Amazon Web Services account.
    ///
    /// Parameters:
    ///   - delegatedAdminAccount:  The delegated administrator account for Audit Manager.
    ///   - kmsKey:  The KMS key details.
    ///   - logger: Logger use during operation
    @inlinable
    public func registerAccount(
        delegatedAdminAccount: String? = nil,
        kmsKey: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RegisterAccountResponse {
        let input = RegisterAccountRequest(
            delegatedAdminAccount: delegatedAdminAccount, 
            kmsKey: kmsKey
        )
        return try await self.registerAccount(input, logger: logger)
    }

    ///  Enables an Amazon Web Services account within the organization as the delegated administrator for Audit Manager.
    @Sendable
    @inlinable
    public func registerOrganizationAdminAccount(_ input: RegisterOrganizationAdminAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RegisterOrganizationAdminAccountResponse {
        try await self.client.execute(
            operation: "RegisterOrganizationAdminAccount", 
            path: "/account/registerOrganizationAdminAccount", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Enables an Amazon Web Services account within the organization as the delegated administrator for Audit Manager.
    ///
    /// Parameters:
    ///   - adminAccountId:  The identifier for the delegated administrator account.
    ///   - logger: Logger use during operation
    @inlinable
    public func registerOrganizationAdminAccount(
        adminAccountId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RegisterOrganizationAdminAccountResponse {
        let input = RegisterOrganizationAdminAccountRequest(
            adminAccountId: adminAccountId
        )
        return try await self.registerOrganizationAdminAccount(input, logger: logger)
    }

    ///  Creates a share request for a custom framework in Audit Manager.  The share request specifies a recipient and notifies them that a custom framework is available. Recipients have 120 days to accept or decline the request. If no action is taken, the share request expires. When you create a share request, Audit Manager stores a snapshot of your custom framework in the US East (N. Virginia) Amazon Web Services Region. Audit Manager also stores a backup of the same snapshot in the US West (Oregon) Amazon Web Services Region. Audit Manager deletes the snapshot and the backup snapshot when one of the following events occurs:   The sender revokes the share request.   The recipient declines the share request.   The recipient encounters an error and doesn't successfully accept the share request.   The share request expires before the recipient responds to the request.   When a sender resends a share request, the snapshot is replaced with an updated version that corresponds with the latest version of the custom framework.  When a recipient accepts a share request, the snapshot is replicated into their Amazon Web Services account under the Amazon Web Services Region that was specified in the share request.   When you invoke the StartAssessmentFrameworkShare API, you are about to share a custom framework with another Amazon Web Services account. You may not share a custom framework that is derived from a standard framework if the standard framework is designated as not eligible for sharing by Amazon Web Services, unless you have obtained permission to do so from the owner of the standard framework. To learn more about which standard frameworks are eligible for sharing, see Framework sharing eligibility in the Audit Manager User Guide.
    @Sendable
    @inlinable
    public func startAssessmentFrameworkShare(_ input: StartAssessmentFrameworkShareRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartAssessmentFrameworkShareResponse {
        try await self.client.execute(
            operation: "StartAssessmentFrameworkShare", 
            path: "/assessmentFrameworks/{frameworkId}/shareRequests", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates a share request for a custom framework in Audit Manager.  The share request specifies a recipient and notifies them that a custom framework is available. Recipients have 120 days to accept or decline the request. If no action is taken, the share request expires. When you create a share request, Audit Manager stores a snapshot of your custom framework in the US East (N. Virginia) Amazon Web Services Region. Audit Manager also stores a backup of the same snapshot in the US West (Oregon) Amazon Web Services Region. Audit Manager deletes the snapshot and the backup snapshot when one of the following events occurs:   The sender revokes the share request.   The recipient declines the share request.   The recipient encounters an error and doesn't successfully accept the share request.   The share request expires before the recipient responds to the request.   When a sender resends a share request, the snapshot is replaced with an updated version that corresponds with the latest version of the custom framework.  When a recipient accepts a share request, the snapshot is replicated into their Amazon Web Services account under the Amazon Web Services Region that was specified in the share request.   When you invoke the StartAssessmentFrameworkShare API, you are about to share a custom framework with another Amazon Web Services account. You may not share a custom framework that is derived from a standard framework if the standard framework is designated as not eligible for sharing by Amazon Web Services, unless you have obtained permission to do so from the owner of the standard framework. To learn more about which standard frameworks are eligible for sharing, see Framework sharing eligibility in the Audit Manager User Guide.
    ///
    /// Parameters:
    ///   - comment:  An optional comment from the sender about the share request.
    ///   - destinationAccount:  The Amazon Web Services account of the recipient.
    ///   - destinationRegion:  The Amazon Web Services Region of the recipient.
    ///   - frameworkId:  The unique identifier for the custom framework to be shared.
    ///   - logger: Logger use during operation
    @inlinable
    public func startAssessmentFrameworkShare(
        comment: String? = nil,
        destinationAccount: String,
        destinationRegion: String,
        frameworkId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartAssessmentFrameworkShareResponse {
        let input = StartAssessmentFrameworkShareRequest(
            comment: comment, 
            destinationAccount: destinationAccount, 
            destinationRegion: destinationRegion, 
            frameworkId: frameworkId
        )
        return try await self.startAssessmentFrameworkShare(input, logger: logger)
    }

    ///  Tags the specified resource in Audit Manager.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Tags the specified resource in Audit Manager.
    ///
    /// Parameters:
    ///   - resourceArn:  The Amazon Resource Name (ARN) of the resource.
    ///   - tags:  The tags that are associated with the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    ///  Removes a tag from a resource in Audit Manager.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Removes a tag from a resource in Audit Manager.
    ///
    /// Parameters:
    ///   - resourceArn:  The Amazon Resource Name (ARN) of the specified resource.
    ///   - tagKeys:  The name or key of the tag.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    ///  Edits an Audit Manager assessment.
    @Sendable
    @inlinable
    public func updateAssessment(_ input: UpdateAssessmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAssessmentResponse {
        try await self.client.execute(
            operation: "UpdateAssessment", 
            path: "/assessments/{assessmentId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Edits an Audit Manager assessment.
    ///
    /// Parameters:
    ///   - assessmentDescription:  The description of the assessment.
    ///   - assessmentId:  The unique identifier for the assessment.
    ///   - assessmentName:  The name of the assessment to be updated.
    ///   - assessmentReportsDestination:  The assessment report storage destination for the assessment that's being updated.
    ///   - roles:  The list of roles for the assessment.
    ///   - scope:  The scope of the assessment.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAssessment(
        assessmentDescription: String? = nil,
        assessmentId: String,
        assessmentName: String? = nil,
        assessmentReportsDestination: AssessmentReportsDestination? = nil,
        roles: [Role]? = nil,
        scope: Scope,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAssessmentResponse {
        let input = UpdateAssessmentRequest(
            assessmentDescription: assessmentDescription, 
            assessmentId: assessmentId, 
            assessmentName: assessmentName, 
            assessmentReportsDestination: assessmentReportsDestination, 
            roles: roles, 
            scope: scope
        )
        return try await self.updateAssessment(input, logger: logger)
    }

    ///  Updates a control within an assessment in Audit Manager.
    @Sendable
    @inlinable
    public func updateAssessmentControl(_ input: UpdateAssessmentControlRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAssessmentControlResponse {
        try await self.client.execute(
            operation: "UpdateAssessmentControl", 
            path: "/assessments/{assessmentId}/controlSets/{controlSetId}/controls/{controlId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates a control within an assessment in Audit Manager.
    ///
    /// Parameters:
    ///   - assessmentId:  The unique identifier for the assessment.
    ///   - commentBody:  The comment body text for the control.
    ///   - controlId:  The unique identifier for the control.
    ///   - controlSetId:  The unique identifier for the control set.
    ///   - controlStatus:  The status of the control.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAssessmentControl(
        assessmentId: String,
        commentBody: String? = nil,
        controlId: String,
        controlSetId: String,
        controlStatus: ControlStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAssessmentControlResponse {
        let input = UpdateAssessmentControlRequest(
            assessmentId: assessmentId, 
            commentBody: commentBody, 
            controlId: controlId, 
            controlSetId: controlSetId, 
            controlStatus: controlStatus
        )
        return try await self.updateAssessmentControl(input, logger: logger)
    }

    ///  Updates the status of a control set in an Audit Manager assessment.
    @Sendable
    @inlinable
    public func updateAssessmentControlSetStatus(_ input: UpdateAssessmentControlSetStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAssessmentControlSetStatusResponse {
        try await self.client.execute(
            operation: "UpdateAssessmentControlSetStatus", 
            path: "/assessments/{assessmentId}/controlSets/{controlSetId}/status", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates the status of a control set in an Audit Manager assessment.
    ///
    /// Parameters:
    ///   - assessmentId:  The unique identifier for the assessment.
    ///   - comment:  The comment that's related to the status update.
    ///   - controlSetId:  The unique identifier for the control set.
    ///   - status:  The status of the control set that's being updated.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAssessmentControlSetStatus(
        assessmentId: String,
        comment: String,
        controlSetId: String,
        status: ControlSetStatus,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAssessmentControlSetStatusResponse {
        let input = UpdateAssessmentControlSetStatusRequest(
            assessmentId: assessmentId, 
            comment: comment, 
            controlSetId: controlSetId, 
            status: status
        )
        return try await self.updateAssessmentControlSetStatus(input, logger: logger)
    }

    ///  Updates a custom framework in Audit Manager.
    @Sendable
    @inlinable
    public func updateAssessmentFramework(_ input: UpdateAssessmentFrameworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAssessmentFrameworkResponse {
        try await self.client.execute(
            operation: "UpdateAssessmentFramework", 
            path: "/assessmentFrameworks/{frameworkId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates a custom framework in Audit Manager.
    ///
    /// Parameters:
    ///   - complianceType:  The compliance type that the new custom framework supports, such as CIS or HIPAA.
    ///   - controlSets:  The control sets that are associated with the framework.
    ///   - description:  The description of the updated framework.
    ///   - frameworkId:  The unique identifier for the framework.
    ///   - name:  The name of the framework to be updated.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAssessmentFramework(
        complianceType: String? = nil,
        controlSets: [UpdateAssessmentFrameworkControlSet],
        description: String? = nil,
        frameworkId: String,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAssessmentFrameworkResponse {
        let input = UpdateAssessmentFrameworkRequest(
            complianceType: complianceType, 
            controlSets: controlSets, 
            description: description, 
            frameworkId: frameworkId, 
            name: name
        )
        return try await self.updateAssessmentFramework(input, logger: logger)
    }

    ///  Updates a share request for a custom framework in Audit Manager.
    @Sendable
    @inlinable
    public func updateAssessmentFrameworkShare(_ input: UpdateAssessmentFrameworkShareRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAssessmentFrameworkShareResponse {
        try await self.client.execute(
            operation: "UpdateAssessmentFrameworkShare", 
            path: "/assessmentFrameworkShareRequests/{requestId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates a share request for a custom framework in Audit Manager.
    ///
    /// Parameters:
    ///   - action: Specifies the update action for the share request.
    ///   - requestId:  The unique identifier for the share request.
    ///   - requestType: Specifies whether the share request is a sent request or a received request.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAssessmentFrameworkShare(
        action: ShareRequestAction,
        requestId: String,
        requestType: ShareRequestType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAssessmentFrameworkShareResponse {
        let input = UpdateAssessmentFrameworkShareRequest(
            action: action, 
            requestId: requestId, 
            requestType: requestType
        )
        return try await self.updateAssessmentFrameworkShare(input, logger: logger)
    }

    ///  Updates the status of an assessment in Audit Manager.
    @Sendable
    @inlinable
    public func updateAssessmentStatus(_ input: UpdateAssessmentStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAssessmentStatusResponse {
        try await self.client.execute(
            operation: "UpdateAssessmentStatus", 
            path: "/assessments/{assessmentId}/status", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates the status of an assessment in Audit Manager.
    ///
    /// Parameters:
    ///   - assessmentId:  The unique identifier for the assessment.
    ///   - status:  The current status of the assessment.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAssessmentStatus(
        assessmentId: String,
        status: AssessmentStatus,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAssessmentStatusResponse {
        let input = UpdateAssessmentStatusRequest(
            assessmentId: assessmentId, 
            status: status
        )
        return try await self.updateAssessmentStatus(input, logger: logger)
    }

    ///  Updates a custom control in Audit Manager.
    @Sendable
    @inlinable
    public func updateControl(_ input: UpdateControlRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateControlResponse {
        try await self.client.execute(
            operation: "UpdateControl", 
            path: "/controls/{controlId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates a custom control in Audit Manager.
    ///
    /// Parameters:
    ///   - actionPlanInstructions:  The recommended actions to carry out if the control isn't fulfilled.
    ///   - actionPlanTitle:  The title of the action plan for remediating the control.
    ///   - controlId:  The identifier for the control.
    ///   - controlMappingSources:  The data mapping sources for the control.
    ///   - description:  The optional description of the control.
    ///   - name:  The name of the updated control.
    ///   - testingInformation:  The steps that you should follow to determine if the control is met.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateControl(
        actionPlanInstructions: String? = nil,
        actionPlanTitle: String? = nil,
        controlId: String,
        controlMappingSources: [ControlMappingSource],
        description: String? = nil,
        name: String,
        testingInformation: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateControlResponse {
        let input = UpdateControlRequest(
            actionPlanInstructions: actionPlanInstructions, 
            actionPlanTitle: actionPlanTitle, 
            controlId: controlId, 
            controlMappingSources: controlMappingSources, 
            description: description, 
            name: name, 
            testingInformation: testingInformation
        )
        return try await self.updateControl(input, logger: logger)
    }

    ///  Updates Audit Manager settings for the current account.
    @Sendable
    @inlinable
    public func updateSettings(_ input: UpdateSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSettingsResponse {
        try await self.client.execute(
            operation: "UpdateSettings", 
            path: "/settings", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates Audit Manager settings for the current account.
    ///
    /// Parameters:
    ///   - defaultAssessmentReportsDestination:  The default S3 destination bucket for storing assessment reports.
    ///   - defaultExportDestination:  The default S3 destination bucket for storing evidence finder exports.
    ///   - defaultProcessOwners:  A list of the default audit owners.
    ///   - deregistrationPolicy: The deregistration policy for your Audit Manager data. You can use this attribute to determine how your data is handled when you deregister Audit Manager.
    ///   - evidenceFinderEnabled: Specifies whether the evidence finder feature is enabled. Change this attribute to enable or disable evidence finder.  When you use this attribute to disable evidence finder, Audit Manager deletes the event data store that’s used to query your evidence data. As a result, you can’t re-enable evidence finder and use the feature again. Your only alternative is to deregister and then re-register Audit Manager.
    ///   - kmsKey:  The KMS key details.
    ///   - snsTopic:  The Amazon Simple Notification Service (Amazon SNS) topic that Audit Manager sends notifications to.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSettings(
        defaultAssessmentReportsDestination: AssessmentReportsDestination? = nil,
        defaultExportDestination: DefaultExportDestination? = nil,
        defaultProcessOwners: [Role]? = nil,
        deregistrationPolicy: DeregistrationPolicy? = nil,
        evidenceFinderEnabled: Bool? = nil,
        kmsKey: String? = nil,
        snsTopic: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSettingsResponse {
        let input = UpdateSettingsRequest(
            defaultAssessmentReportsDestination: defaultAssessmentReportsDestination, 
            defaultExportDestination: defaultExportDestination, 
            defaultProcessOwners: defaultProcessOwners, 
            deregistrationPolicy: deregistrationPolicy, 
            evidenceFinderEnabled: evidenceFinderEnabled, 
            kmsKey: kmsKey, 
            snsTopic: snsTopic
        )
        return try await self.updateSettings(input, logger: logger)
    }

    ///  Validates the integrity of an assessment report in Audit Manager.
    @Sendable
    @inlinable
    public func validateAssessmentReportIntegrity(_ input: ValidateAssessmentReportIntegrityRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ValidateAssessmentReportIntegrityResponse {
        try await self.client.execute(
            operation: "ValidateAssessmentReportIntegrity", 
            path: "/assessmentReports/integrity", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Validates the integrity of an assessment report in Audit Manager.
    ///
    /// Parameters:
    ///   - s3RelativePath:  The relative path of the Amazon S3 bucket that the assessment report is stored in.
    ///   - logger: Logger use during operation
    @inlinable
    public func validateAssessmentReportIntegrity(
        s3RelativePath: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ValidateAssessmentReportIntegrityResponse {
        let input = ValidateAssessmentReportIntegrityRequest(
            s3RelativePath: s3RelativePath
        )
        return try await self.validateAssessmentReportIntegrity(input, logger: logger)
    }
}

extension AuditManager {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: AuditManager, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension AuditManager {
    /// Return PaginatorSequence for operation ``getChangeLogs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getChangeLogsPaginator(
        _ input: GetChangeLogsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetChangeLogsRequest, GetChangeLogsResponse> {
        return .init(
            input: input,
            command: self.getChangeLogs,
            inputKey: \GetChangeLogsRequest.nextToken,
            outputKey: \GetChangeLogsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getChangeLogs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - assessmentId: The unique identifier for the assessment.
    ///   - controlId:  The unique identifier for the control.
    ///   - controlSetId:  The unique identifier for the control set.
    ///   - maxResults: Represents the maximum number of results on a page or for an API request call.
    ///   - logger: Logger used for logging
    @inlinable
    public func getChangeLogsPaginator(
        assessmentId: String,
        controlId: String? = nil,
        controlSetId: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetChangeLogsRequest, GetChangeLogsResponse> {
        let input = GetChangeLogsRequest(
            assessmentId: assessmentId, 
            controlId: controlId, 
            controlSetId: controlSetId, 
            maxResults: maxResults
        )
        return self.getChangeLogsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getDelegations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getDelegationsPaginator(
        _ input: GetDelegationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetDelegationsRequest, GetDelegationsResponse> {
        return .init(
            input: input,
            command: self.getDelegations,
            inputKey: \GetDelegationsRequest.nextToken,
            outputKey: \GetDelegationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getDelegations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - logger: Logger used for logging
    @inlinable
    public func getDelegationsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetDelegationsRequest, GetDelegationsResponse> {
        let input = GetDelegationsRequest(
            maxResults: maxResults
        )
        return self.getDelegationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getEvidenceByEvidenceFolder(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getEvidenceByEvidenceFolderPaginator(
        _ input: GetEvidenceByEvidenceFolderRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetEvidenceByEvidenceFolderRequest, GetEvidenceByEvidenceFolderResponse> {
        return .init(
            input: input,
            command: self.getEvidenceByEvidenceFolder,
            inputKey: \GetEvidenceByEvidenceFolderRequest.nextToken,
            outputKey: \GetEvidenceByEvidenceFolderResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getEvidenceByEvidenceFolder(_:logger:)``.
    ///
    /// - Parameters:
    ///   - assessmentId:  The identifier for the assessment.
    ///   - controlSetId:  The identifier for the control set.
    ///   - evidenceFolderId:  The unique identifier for the folder that the evidence is stored in.
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - logger: Logger used for logging
    @inlinable
    public func getEvidenceByEvidenceFolderPaginator(
        assessmentId: String,
        controlSetId: String,
        evidenceFolderId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetEvidenceByEvidenceFolderRequest, GetEvidenceByEvidenceFolderResponse> {
        let input = GetEvidenceByEvidenceFolderRequest(
            assessmentId: assessmentId, 
            controlSetId: controlSetId, 
            evidenceFolderId: evidenceFolderId, 
            maxResults: maxResults
        )
        return self.getEvidenceByEvidenceFolderPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getEvidenceFoldersByAssessment(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getEvidenceFoldersByAssessmentPaginator(
        _ input: GetEvidenceFoldersByAssessmentRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetEvidenceFoldersByAssessmentRequest, GetEvidenceFoldersByAssessmentResponse> {
        return .init(
            input: input,
            command: self.getEvidenceFoldersByAssessment,
            inputKey: \GetEvidenceFoldersByAssessmentRequest.nextToken,
            outputKey: \GetEvidenceFoldersByAssessmentResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getEvidenceFoldersByAssessment(_:logger:)``.
    ///
    /// - Parameters:
    ///   - assessmentId:  The unique identifier for the assessment.
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - logger: Logger used for logging
    @inlinable
    public func getEvidenceFoldersByAssessmentPaginator(
        assessmentId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetEvidenceFoldersByAssessmentRequest, GetEvidenceFoldersByAssessmentResponse> {
        let input = GetEvidenceFoldersByAssessmentRequest(
            assessmentId: assessmentId, 
            maxResults: maxResults
        )
        return self.getEvidenceFoldersByAssessmentPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getEvidenceFoldersByAssessmentControl(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getEvidenceFoldersByAssessmentControlPaginator(
        _ input: GetEvidenceFoldersByAssessmentControlRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetEvidenceFoldersByAssessmentControlRequest, GetEvidenceFoldersByAssessmentControlResponse> {
        return .init(
            input: input,
            command: self.getEvidenceFoldersByAssessmentControl,
            inputKey: \GetEvidenceFoldersByAssessmentControlRequest.nextToken,
            outputKey: \GetEvidenceFoldersByAssessmentControlResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getEvidenceFoldersByAssessmentControl(_:logger:)``.
    ///
    /// - Parameters:
    ///   - assessmentId:  The identifier for the assessment.
    ///   - controlId:  The identifier for the control.
    ///   - controlSetId:  The identifier for the control set.
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - logger: Logger used for logging
    @inlinable
    public func getEvidenceFoldersByAssessmentControlPaginator(
        assessmentId: String,
        controlId: String,
        controlSetId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetEvidenceFoldersByAssessmentControlRequest, GetEvidenceFoldersByAssessmentControlResponse> {
        let input = GetEvidenceFoldersByAssessmentControlRequest(
            assessmentId: assessmentId, 
            controlId: controlId, 
            controlSetId: controlSetId, 
            maxResults: maxResults
        )
        return self.getEvidenceFoldersByAssessmentControlPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAssessmentControlInsightsByControlDomain(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssessmentControlInsightsByControlDomainPaginator(
        _ input: ListAssessmentControlInsightsByControlDomainRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAssessmentControlInsightsByControlDomainRequest, ListAssessmentControlInsightsByControlDomainResponse> {
        return .init(
            input: input,
            command: self.listAssessmentControlInsightsByControlDomain,
            inputKey: \ListAssessmentControlInsightsByControlDomainRequest.nextToken,
            outputKey: \ListAssessmentControlInsightsByControlDomainResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAssessmentControlInsightsByControlDomain(_:logger:)``.
    ///
    /// - Parameters:
    ///   - assessmentId: The unique identifier for the active assessment.
    ///   - controlDomainId: The unique identifier for the control domain.  Audit Manager supports the control domains that are provided by Amazon Web Services Control Catalog. For information about how to find a list of available control domains, see  ListDomains in the Amazon Web Services Control Catalog API Reference.
    ///   - maxResults: Represents the maximum number of results on a page or for an API request call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssessmentControlInsightsByControlDomainPaginator(
        assessmentId: String,
        controlDomainId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAssessmentControlInsightsByControlDomainRequest, ListAssessmentControlInsightsByControlDomainResponse> {
        let input = ListAssessmentControlInsightsByControlDomainRequest(
            assessmentId: assessmentId, 
            controlDomainId: controlDomainId, 
            maxResults: maxResults
        )
        return self.listAssessmentControlInsightsByControlDomainPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAssessmentFrameworkShareRequests(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssessmentFrameworkShareRequestsPaginator(
        _ input: ListAssessmentFrameworkShareRequestsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAssessmentFrameworkShareRequestsRequest, ListAssessmentFrameworkShareRequestsResponse> {
        return .init(
            input: input,
            command: self.listAssessmentFrameworkShareRequests,
            inputKey: \ListAssessmentFrameworkShareRequestsRequest.nextToken,
            outputKey: \ListAssessmentFrameworkShareRequestsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAssessmentFrameworkShareRequests(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - requestType:  Specifies whether the share request is a sent request or a received request.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssessmentFrameworkShareRequestsPaginator(
        maxResults: Int? = nil,
        requestType: ShareRequestType,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAssessmentFrameworkShareRequestsRequest, ListAssessmentFrameworkShareRequestsResponse> {
        let input = ListAssessmentFrameworkShareRequestsRequest(
            maxResults: maxResults, 
            requestType: requestType
        )
        return self.listAssessmentFrameworkShareRequestsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAssessmentFrameworks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssessmentFrameworksPaginator(
        _ input: ListAssessmentFrameworksRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAssessmentFrameworksRequest, ListAssessmentFrameworksResponse> {
        return .init(
            input: input,
            command: self.listAssessmentFrameworks,
            inputKey: \ListAssessmentFrameworksRequest.nextToken,
            outputKey: \ListAssessmentFrameworksResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAssessmentFrameworks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - frameworkType:  The type of framework, such as a standard framework or a custom framework.
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssessmentFrameworksPaginator(
        frameworkType: FrameworkType,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAssessmentFrameworksRequest, ListAssessmentFrameworksResponse> {
        let input = ListAssessmentFrameworksRequest(
            frameworkType: frameworkType, 
            maxResults: maxResults
        )
        return self.listAssessmentFrameworksPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAssessmentReports(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssessmentReportsPaginator(
        _ input: ListAssessmentReportsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAssessmentReportsRequest, ListAssessmentReportsResponse> {
        return .init(
            input: input,
            command: self.listAssessmentReports,
            inputKey: \ListAssessmentReportsRequest.nextToken,
            outputKey: \ListAssessmentReportsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAssessmentReports(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssessmentReportsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAssessmentReportsRequest, ListAssessmentReportsResponse> {
        let input = ListAssessmentReportsRequest(
            maxResults: maxResults
        )
        return self.listAssessmentReportsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAssessments(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssessmentsPaginator(
        _ input: ListAssessmentsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAssessmentsRequest, ListAssessmentsResponse> {
        return .init(
            input: input,
            command: self.listAssessments,
            inputKey: \ListAssessmentsRequest.nextToken,
            outputKey: \ListAssessmentsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAssessments(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - status:  The current status of the assessment.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssessmentsPaginator(
        maxResults: Int? = nil,
        status: AssessmentStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAssessmentsRequest, ListAssessmentsResponse> {
        let input = ListAssessmentsRequest(
            maxResults: maxResults, 
            status: status
        )
        return self.listAssessmentsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listControlDomainInsights(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listControlDomainInsightsPaginator(
        _ input: ListControlDomainInsightsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListControlDomainInsightsRequest, ListControlDomainInsightsResponse> {
        return .init(
            input: input,
            command: self.listControlDomainInsights,
            inputKey: \ListControlDomainInsightsRequest.nextToken,
            outputKey: \ListControlDomainInsightsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listControlDomainInsights(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Represents the maximum number of results on a page or for an API request call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listControlDomainInsightsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListControlDomainInsightsRequest, ListControlDomainInsightsResponse> {
        let input = ListControlDomainInsightsRequest(
            maxResults: maxResults
        )
        return self.listControlDomainInsightsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listControlDomainInsightsByAssessment(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listControlDomainInsightsByAssessmentPaginator(
        _ input: ListControlDomainInsightsByAssessmentRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListControlDomainInsightsByAssessmentRequest, ListControlDomainInsightsByAssessmentResponse> {
        return .init(
            input: input,
            command: self.listControlDomainInsightsByAssessment,
            inputKey: \ListControlDomainInsightsByAssessmentRequest.nextToken,
            outputKey: \ListControlDomainInsightsByAssessmentResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listControlDomainInsightsByAssessment(_:logger:)``.
    ///
    /// - Parameters:
    ///   - assessmentId: The unique identifier for the active assessment.
    ///   - maxResults: Represents the maximum number of results on a page or for an API request call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listControlDomainInsightsByAssessmentPaginator(
        assessmentId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListControlDomainInsightsByAssessmentRequest, ListControlDomainInsightsByAssessmentResponse> {
        let input = ListControlDomainInsightsByAssessmentRequest(
            assessmentId: assessmentId, 
            maxResults: maxResults
        )
        return self.listControlDomainInsightsByAssessmentPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listControlInsightsByControlDomain(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listControlInsightsByControlDomainPaginator(
        _ input: ListControlInsightsByControlDomainRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListControlInsightsByControlDomainRequest, ListControlInsightsByControlDomainResponse> {
        return .init(
            input: input,
            command: self.listControlInsightsByControlDomain,
            inputKey: \ListControlInsightsByControlDomainRequest.nextToken,
            outputKey: \ListControlInsightsByControlDomainResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listControlInsightsByControlDomain(_:logger:)``.
    ///
    /// - Parameters:
    ///   - controlDomainId: The unique identifier for the control domain.  Audit Manager supports the control domains that are provided by Amazon Web Services Control Catalog. For information about how to find a list of available control domains, see  ListDomains in the Amazon Web Services Control Catalog API Reference.
    ///   - maxResults: Represents the maximum number of results on a page or for an API request call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listControlInsightsByControlDomainPaginator(
        controlDomainId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListControlInsightsByControlDomainRequest, ListControlInsightsByControlDomainResponse> {
        let input = ListControlInsightsByControlDomainRequest(
            controlDomainId: controlDomainId, 
            maxResults: maxResults
        )
        return self.listControlInsightsByControlDomainPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listControls(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listControlsPaginator(
        _ input: ListControlsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListControlsRequest, ListControlsResponse> {
        return .init(
            input: input,
            command: self.listControls,
            inputKey: \ListControlsRequest.nextToken,
            outputKey: \ListControlsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listControls(_:logger:)``.
    ///
    /// - Parameters:
    ///   - controlCatalogId: A filter that narrows the list of controls to a specific resource from the Amazon Web Services  Control Catalog.  To use this parameter, specify the ARN of the Control Catalog resource. You can specify either  a control domain, a control objective, or a common control. For information about how to find the ARNs for these resources, see  ListDomains ,  ListObjectives , and  ListCommonControls .  You can only filter by one Control Catalog resource at a time.  Specifying multiple resource ARNs isn’t currently supported. If you want to filter by more  than one ARN, we recommend that you run the ListControls operation separately  for each ARN.   Alternatively, specify UNCATEGORIZED to list controls that aren't mapped to a Control Catalog resource. For example, this operation might return a list of  custom controls that don't belong to any control domain or control objective.
    ///   - controlType: A filter that narrows the list of controls to a specific type.
    ///   - maxResults: The maximum number of results on a page or for an API request call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listControlsPaginator(
        controlCatalogId: String? = nil,
        controlType: ControlType,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListControlsRequest, ListControlsResponse> {
        let input = ListControlsRequest(
            controlCatalogId: controlCatalogId, 
            controlType: controlType, 
            maxResults: maxResults
        )
        return self.listControlsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listKeywordsForDataSource(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listKeywordsForDataSourcePaginator(
        _ input: ListKeywordsForDataSourceRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListKeywordsForDataSourceRequest, ListKeywordsForDataSourceResponse> {
        return .init(
            input: input,
            command: self.listKeywordsForDataSource,
            inputKey: \ListKeywordsForDataSourceRequest.nextToken,
            outputKey: \ListKeywordsForDataSourceResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listKeywordsForDataSource(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - source: The control mapping data source that the keywords apply to.
    ///   - logger: Logger used for logging
    @inlinable
    public func listKeywordsForDataSourcePaginator(
        maxResults: Int? = nil,
        source: DataSourceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListKeywordsForDataSourceRequest, ListKeywordsForDataSourceResponse> {
        let input = ListKeywordsForDataSourceRequest(
            maxResults: maxResults, 
            source: source
        )
        return self.listKeywordsForDataSourcePaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listNotifications(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listNotificationsPaginator(
        _ input: ListNotificationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListNotificationsRequest, ListNotificationsResponse> {
        return .init(
            input: input,
            command: self.listNotifications,
            inputKey: \ListNotificationsRequest.nextToken,
            outputKey: \ListNotificationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listNotifications(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults:  Represents the maximum number of results on a page or for an API request call.
    ///   - logger: Logger used for logging
    @inlinable
    public func listNotificationsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListNotificationsRequest, ListNotificationsResponse> {
        let input = ListNotificationsRequest(
            maxResults: maxResults
        )
        return self.listNotificationsPaginator(input, logger: logger)
    }
}

extension AuditManager.GetChangeLogsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.GetChangeLogsRequest {
        return .init(
            assessmentId: self.assessmentId,
            controlId: self.controlId,
            controlSetId: self.controlSetId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension AuditManager.GetDelegationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.GetDelegationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension AuditManager.GetEvidenceByEvidenceFolderRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.GetEvidenceByEvidenceFolderRequest {
        return .init(
            assessmentId: self.assessmentId,
            controlSetId: self.controlSetId,
            evidenceFolderId: self.evidenceFolderId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension AuditManager.GetEvidenceFoldersByAssessmentControlRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.GetEvidenceFoldersByAssessmentControlRequest {
        return .init(
            assessmentId: self.assessmentId,
            controlId: self.controlId,
            controlSetId: self.controlSetId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension AuditManager.GetEvidenceFoldersByAssessmentRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.GetEvidenceFoldersByAssessmentRequest {
        return .init(
            assessmentId: self.assessmentId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension AuditManager.ListAssessmentControlInsightsByControlDomainRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.ListAssessmentControlInsightsByControlDomainRequest {
        return .init(
            assessmentId: self.assessmentId,
            controlDomainId: self.controlDomainId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension AuditManager.ListAssessmentFrameworkShareRequestsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.ListAssessmentFrameworkShareRequestsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            requestType: self.requestType
        )
    }
}

extension AuditManager.ListAssessmentFrameworksRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.ListAssessmentFrameworksRequest {
        return .init(
            frameworkType: self.frameworkType,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension AuditManager.ListAssessmentReportsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.ListAssessmentReportsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension AuditManager.ListAssessmentsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.ListAssessmentsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            status: self.status
        )
    }
}

extension AuditManager.ListControlDomainInsightsByAssessmentRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.ListControlDomainInsightsByAssessmentRequest {
        return .init(
            assessmentId: self.assessmentId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension AuditManager.ListControlDomainInsightsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.ListControlDomainInsightsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension AuditManager.ListControlInsightsByControlDomainRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.ListControlInsightsByControlDomainRequest {
        return .init(
            controlDomainId: self.controlDomainId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension AuditManager.ListControlsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.ListControlsRequest {
        return .init(
            controlCatalogId: self.controlCatalogId,
            controlType: self.controlType,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension AuditManager.ListKeywordsForDataSourceRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.ListKeywordsForDataSourceRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            source: self.source
        )
    }
}

extension AuditManager.ListNotificationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> AuditManager.ListNotificationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}
